const express = require('express');
const router = express.Router();
const { createSuccessResponse } = require('../../middleware/responseHandler');
const { Op } = require('sequelize');
const {
    note,
    getCreateDefaults,
    getUpdateDefaults,
    NOTE_TYPE,
    NOTE_STATUS,
    NOTE_LEVEL,
    ANONYMOUS_STATUS
} = require('../../models/note');

/**
 * 获取留言列表
 * @param {number} page - 页码，默认1
 * @param {number} pageSize - 每页数量，默认10
 * @param {number} note_type - 留言类型筛选
 * @param {number} note_status - 留言状态筛选
 * @param {number} note_level - 留言等级筛选
 * @param {string} search - 搜索关键词
 * @param {number} user_id - 用户ID筛选
 * @param {number} is_anonymous - 是否匿名筛选
 * @returns {Promise<object>} 返回留言列表
 */
router.post("/getNoteList", (req, res, next) => {
    const {
        page = 1,
        pageSize = 10,
        note_type,
        note_status,
        note_level,
        search = '',
        user_id,
        is_anonymous
    } = req.body;

    // 构建查询条件
    let whereCondition = {
        is_delete: 0
    };

    // 留言类型筛选
    if (note_type !== undefined && note_type !== null) {
        whereCondition.note_type = note_type;
    }

    // 留言状态筛选
    if (note_status !== undefined && note_status !== null) {
        whereCondition.note_status = note_status;
    }

    // 留言等级筛选
    if (note_level !== undefined && note_level !== null) {
        whereCondition.note_level = note_level;
    }

    // 用户ID筛选
    if (user_id !== undefined && user_id !== null) {
        whereCondition.user_id = user_id;
    }

    // 是否匿名筛选
    if (is_anonymous !== undefined && is_anonymous !== null) {
        whereCondition.is_anonymous = is_anonymous;
    }

    // 搜索条件
    if (search) {
        whereCondition[Op.or] = [
            { note_title: { [Op.like]: `%${search}%` } },
            { note_content: { [Op.like]: `%${search}%` } },
            { name_cn: { [Op.like]: `%${search}%` } },
            { name_en: { [Op.like]: `%${search}%` } }
        ];
    }

    // 计算偏移量
    const offset = (page - 1) * pageSize;

    return new Promise((resolve, reject) => {
        // 查询总数
        note.count({ where: whereCondition }).then(total => {
            // 查询列表数据
            return note.findAll({
                where: whereCondition,
                order: [['create_time', 'DESC']],
                limit: parseInt(pageSize),
                offset: offset,
                attributes: [
                    'note_id',
                    'identify_code',
                    'user_id',
                    'name_en',
                    'name_cn',
                    'note_type',
                    'note_title',
                    'note_content',
                    'note_images',
                    'note_status',
                    'note_level',
                    'respond_user_id',
                    'respond_content',
                    'respond_time',
                    'is_anonymous',
                    'mobilephone',
                    'create_time',
                    'update_time'
                ]
            });
        }).then(list => {
            // 处理图片字段
            const processedList = list.map(item => {
                const noteData = item.toJSON();
                // 处理图片字段，如果是JSON字符串则解析
                if (noteData.note_images) {
                    try {
                        noteData.note_images = JSON.parse(noteData.note_images);
                    } catch (e) {
                        noteData.note_images = noteData.note_images.split(',').filter(img => img);
                    }
                } else {
                    noteData.note_images = [];
                }
                return noteData;
            });

            resolve({
                success: true,
                code: 200,
                message: "获取留言列表成功",
                data: {
                    list: processedList,
                    pagination: {
                        page: parseInt(page),
                        pageSize: parseInt(pageSize),
                        total: total,
                        totalPages: Math.ceil(total / pageSize)
                    }
                }
            });
        }).catch(error => {
            console.error('获取留言列表错误:', error);
            reject(error);
        });
    }).then(result => {
        res.json(result);
    }).catch(error => {
        console.error('获取留言列表错误:', error);
        next(error);
    });
});

/**
 * 获取留言详情
 * @param {number} note_id - 留言ID
 * @param {string} identify_code - 唯一标识码
 * @returns {Promise<object>} 返回留言详情
 */
router.post("/getNoteById", (req, res, next) => {
    const { note_id, identify_code } = req.body;

    // 参数验证
    if (!note_id && !identify_code) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '请提供留言ID或唯一标识码',
            error: '缺少必要参数'
        });
    }

    // 构建查询条件
    let whereCondition = {
        is_delete: 0
    };

    if (note_id) {
        whereCondition.note_id = note_id;
    } else if (identify_code) {
        whereCondition.identify_code = identify_code;
    }

    return new Promise((resolve, reject) => {
        note.findOne({
            where: whereCondition,
            attributes: [
                'note_id',
                'identify_code',
                'user_id',
                'name_en',
                'name_cn',
                'note_type',
                'note_title',
                'note_content',
                'note_images',
                'note_status',
                'note_level',
                'user_ip',
                'user_agent',
                'respond_user_id',
                'respond_content',
                'respond_time',
                'is_anonymous',
                'mobilephone',
                'create_time',
                'update_time'
            ]
        }).then(noteData => {
            if (!noteData) {
                resolve({
                    success: false,
                    code: 404,
                    message: '留言不存在',
                    error: '留言不存在'
                });
                return;
            }

            // 处理数据
            const processedData = noteData.toJSON();

            // 处理图片字段
            if (processedData.note_images) {
                try {
                    processedData.note_images = JSON.parse(processedData.note_images);
                } catch (e) {
                    processedData.note_images = processedData.note_images.split(',').filter(img => img);
                }
            } else {
                processedData.note_images = [];
            }

            // 添加枚举值说明
            processedData.note_type_text = getNoteTypeText(processedData.note_type);
            processedData.note_status_text = getNoteStatusText(processedData.note_status);
            processedData.note_level_text = getNoteLevelText(processedData.note_level);

            resolve({
                success: true,
                code: 200,
                message: "获取留言详情成功",
                data: processedData
            });
        }).catch(error => {
            console.error('获取留言详情错误:', error);
            reject(error);
        });
    }).then(result => {
        res.json(result);
    }).catch(error => {
        console.error('获取留言详情错误:', error);
        next(error);
    });
});

/**
 * 创建留言
 * @param {number} user_id - 用户ID
 * @param {string} name_en - 用户英文名称
 * @param {string} name_cn - 用户中文名称
 * @param {number} note_type - 留言类型
 * @param {string} note_title - 留言标题
 * @param {string} note_content - 留言内容
 * @param {string} note_images - 留言图片
 * @param {number} note_level - 留言等级
 * @param {number} is_anonymous - 是否匿名
 * @returns {Promise<object>} 返回创建结果
 */
router.post("/createNote", (req, res, next) => {
    const {
        user_id,
        name_en = '',
        name_cn = '',
        note_type = NOTE_TYPE.OTHER,
        note_title,
        note_content = '',
        note_images = '',
        note_level = NOTE_LEVEL.NORMAL,
        is_anonymous = 0,
        mobilephone = ''
    } = req.body;

    // 参数验证
    if (!note_title) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '留言标题不能为空',
            error: '留言标题不能为空'
        });
    }

    return new Promise((resolve, reject) => {
        // 获取客户端信息
        const user_ip = req.ip || req.connection.remoteAddress;
        const user_agent = req.headers['user-agent'] || '';

        // 构建创建数据
        const createData = {
            ...getCreateDefaults(),
            user_id: user_id || 0,
            name_en,
            name_cn,
            note_type,
            note_title,
            note_content,
            note_images: Array.isArray(note_images) ? JSON.stringify(note_images) : note_images,
            note_level,
            user_ip,
            user_agent,
            is_anonymous,
            mobilephone
        };

        note.create(createData).then(createdNote => {
            resolve({
                success: true,
                code: 200,
                message: "创建留言成功",
                data: {
                    note_id: createdNote.note_id,
                    identify_code: createdNote.identify_code
                }
            });
        }).catch(error => {
            console.error('创建留言错误:', error);
            reject(error);
        });
    }).then(result => {
        res.json(result);
    }).catch(error => {
        console.error('创建留言错误:', error);
        next(error);
    });
});

/**
 * 更新留言
 * @param {number} note_id - 留言ID
 * @param {string} identify_code - 唯一标识码
 * @param {object} updateData - 更新数据
 * @returns {Promise<object>} 返回更新结果
 */
router.post("/updateNote", (req, res, next) => {
    const { note_id, identify_code, ...updateData } = req.body;

    // 参数验证
    if (!note_id && !identify_code) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '请提供留言ID或唯一标识码',
            error: '缺少必要参数'
        });
    }

    return new Promise((resolve, reject) => {
        // 构建查询条件
        let whereCondition = {
            is_delete: 0
        };

        if (note_id) {
            whereCondition.note_id = note_id;
        } else if (identify_code) {
            whereCondition.identify_code = identify_code;
        }

        // 处理图片字段
        if (updateData.note_images && Array.isArray(updateData.note_images)) {
            updateData.note_images = JSON.stringify(updateData.note_images);
        }

        // 添加更新时间
        updateData.update_time = Math.floor(Date.now() / 1000);

        note.update(updateData, {
            where: whereCondition
        }).then(([affectedRows]) => {
            if (affectedRows === 0) {
                resolve({
                    success: false,
                    code: 404,
                    message: '留言不存在或无法更新',
                    error: '留言不存在或无法更新'
                });
                return;
            }

            resolve({
                success: true,
                code: 200,
                message: "更新留言成功",
                data: { affectedRows }
            });
        }).catch(error => {
            console.error('更新留言错误:', error);
            reject(error);
        });
    }).then(result => {
        res.json(result);
    }).catch(error => {
        console.error('更新留言错误:', error);
        next(error);
    });
});

/**
 * 删除留言（软删除）
 * @param {number} note_id - 留言ID
 * @param {string} identify_code - 唯一标识码
 * @returns {Promise<object>} 返回删除结果
 */
router.post("/deleteNote", (req, res, next) => {
    const { note_id, identify_code } = req.body;

    // 参数验证
    if (!note_id && !identify_code) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '请提供留言ID或唯一标识码',
            error: '缺少必要参数'
        });
    }

    return new Promise((resolve, reject) => {
        // 构建查询条件
        let whereCondition = {
            is_delete: 0
        };

        if (note_id) {
            whereCondition.note_id = note_id;
        } else if (identify_code) {
            whereCondition.identify_code = identify_code;
        }

        note.update({
            is_delete: 1,
            update_time: Math.floor(Date.now() / 1000)
        }, {
            where: whereCondition
        }).then(([affectedRows]) => {
            if (affectedRows === 0) {
                resolve({
                    success: false,
                    code: 404,
                    message: '留言不存在或无法删除',
                    error: '留言不存在或无法删除'
                });
                return;
            }

            resolve({
                success: true,
                code: 200,
                message: "删除留言成功",
                data: { affectedRows }
            });
        }).catch(error => {
            console.error('删除留言错误:', error);
            reject(error);
        });
    }).then(result => {
        res.json(result);
    }).catch(error => {
        console.error('删除留言错误:', error);
        next(error);
    });
});

// 辅助函数：获取留言类型文本
const getNoteTypeText = (type) => {
    const typeMap = {
        [NOTE_TYPE.OTHER]: '其他',
        [NOTE_TYPE.SUGGESTION]: '建议',
        [NOTE_TYPE.BUG]: 'BUG',
        [NOTE_TYPE.COMPLAINT]: '投诉'
    };
    return typeMap[type] || '未知';
};

// 辅助函数：获取留言状态文本
const getNoteStatusText = (status) => {
    const statusMap = {
        [NOTE_STATUS.PENDING]: '待处理',
        [NOTE_STATUS.PROCESSING]: '处理中',
        [NOTE_STATUS.PROCESSED]: '已处理',
        [NOTE_STATUS.CLOSED]: '已关闭'
    };
    return statusMap[status] || '未知';
};

// 辅助函数：获取留言等级文本
const getNoteLevelText = (level) => {
    const levelMap = {
        [NOTE_LEVEL.NORMAL]: '普通',
        [NOTE_LEVEL.IMPORTANT]: '重要',
        [NOTE_LEVEL.URGENT]: '紧急'
    };
    return levelMap[level] || '未知';
};

module.exports = router;
